/*
 * Copyright 2016 Google Inc. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.devrel.gmscore.tools.apk.arsc;

import com.google.auto.value.AutoValue;
import com.google.common.base.Charsets;
import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.primitives.Bytes;
import com.google.common.primitives.UnsignedBytes;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/** Describes a particular resource configuration. */
@AutoValue
public abstract class ResourceConfiguration implements SerializableResource {

  /**
   * The different types of configs that can be present in a {@link ResourceConfiguration}.
   *
   * <p>The ordering of these types is roughly the same as {@code #isBetterThan}, but is not
   * guaranteed to be the same.
   */
  public enum Type {
    MCC,
    MNC,
    LANGUAGE_STRING,
    LOCALE_SCRIPT_STRING,
    REGION_STRING,
    LOCALE_VARIANT_STRING,
    SCREEN_LAYOUT_DIRECTION,
    SMALLEST_SCREEN_WIDTH_DP,
    SCREEN_WIDTH_DP,
    SCREEN_HEIGHT_DP,
    SCREEN_LAYOUT_SIZE,
    SCREEN_LAYOUT_LONG,
    SCREEN_LAYOUT_ROUND,
    COLOR_MODE_WIDE_COLOR_GAMUT, // NB: COLOR_GAMUT takes priority over HDR in #isBetterThan.
    COLOR_MODE_HDR,
    ORIENTATION,
    UI_MODE_TYPE,
    UI_MODE_NIGHT,
    DENSITY_DPI,
    TOUCHSCREEN,
    KEYBOARD_HIDDEN,
    KEYBOARD,
    NAVIGATION_HIDDEN,
    NAVIGATION,
    SCREEN_SIZE,
    SDK_VERSION
  }

  private static final ResourceConfiguration.Builder DEFAULT_BUILDER = builder();

  /**
   * The default configuration. This configuration acts as a "catch-all" for looking up resources
   * when no better configuration can be found.
   */
  public static final ResourceConfiguration DEFAULT = DEFAULT_BUILDER.build();

  /** The below constants are from android.content.res.Configuration. */
  static final int COLOR_MODE_WIDE_COLOR_GAMUT_MASK = 0x03;

  static final int COLOR_MODE_WIDE_COLOR_GAMUT_UNDEFINED = 0;
  static final int COLOR_MODE_WIDE_COLOR_GAMUT_NO = 0x01;
  static final int COLOR_MODE_WIDE_COLOR_GAMUT_YES = 0x02;

  private static final Map<Integer, String> COLOR_MODE_WIDE_COLOR_GAMUT_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(COLOR_MODE_WIDE_COLOR_GAMUT_UNDEFINED, "");
    map.put(COLOR_MODE_WIDE_COLOR_GAMUT_NO, "nowidecg");
    map.put(COLOR_MODE_WIDE_COLOR_GAMUT_YES, "widecg");
    COLOR_MODE_WIDE_COLOR_GAMUT_VALUES = Collections.unmodifiableMap(map);
  }

  static final int COLOR_MODE_HDR_MASK = 0x0C;
  static final int COLOR_MODE_HDR_UNDEFINED = 0;
  static final int COLOR_MODE_HDR_NO = 0x04;
  static final int COLOR_MODE_HDR_YES = 0x08;

  private static final Map<Integer, String> COLOR_MODE_HDR_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(COLOR_MODE_HDR_UNDEFINED, "");
    map.put(COLOR_MODE_HDR_NO, "lowdr");
    map.put(COLOR_MODE_HDR_YES, "highdr");
    COLOR_MODE_HDR_VALUES = Collections.unmodifiableMap(map);
  }

  static final int DENSITY_DPI_UNDEFINED = 0;
  static final int DENSITY_DPI_LDPI = 120;
  static final int DENSITY_DPI_MDPI = 160;
  static final int DENSITY_DPI_TVDPI = 213;
  static final int DENSITY_DPI_HDPI = 240;
  static final int DENSITY_DPI_XHDPI = 320;
  static final int DENSITY_DPI_XXHDPI = 480;
  static final int DENSITY_DPI_XXXHDPI = 640;
  static final int DENSITY_DPI_ANY  = 0xFFFE;
  static final int DENSITY_DPI_NONE = 0xFFFF;

  private static final Map<Integer, String> DENSITY_DPI_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(DENSITY_DPI_UNDEFINED, "");
    map.put(DENSITY_DPI_LDPI, "ldpi");
    map.put(DENSITY_DPI_MDPI, "mdpi");
    map.put(DENSITY_DPI_TVDPI, "tvdpi");
    map.put(DENSITY_DPI_HDPI, "hdpi");
    map.put(DENSITY_DPI_XHDPI, "xhdpi");
    map.put(DENSITY_DPI_XXHDPI, "xxhdpi");
    map.put(DENSITY_DPI_XXXHDPI, "xxxhdpi");
    map.put(DENSITY_DPI_ANY, "anydpi");
    map.put(DENSITY_DPI_NONE, "nodpi");
    DENSITY_DPI_VALUES = Collections.unmodifiableMap(map);
  }

  static final int KEYBOARD_NOKEYS = 1;
  static final int KEYBOARD_QWERTY = 2;
  static final int KEYBOARD_12KEY  = 3;

  private static final Map<Integer, String> KEYBOARD_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(KEYBOARD_NOKEYS, "nokeys");
    map.put(KEYBOARD_QWERTY, "qwerty");
    map.put(KEYBOARD_12KEY, "12key");
    KEYBOARD_VALUES = Collections.unmodifiableMap(map);
  }

  static final int KEYBOARDHIDDEN_MASK = 0x03;
  static final int KEYBOARDHIDDEN_NO   = 1;
  static final int KEYBOARDHIDDEN_YES  = 2;
  static final int KEYBOARDHIDDEN_SOFT = 3;

  private static final Map<Integer, String> KEYBOARDHIDDEN_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(KEYBOARDHIDDEN_NO, "keysexposed");
    map.put(KEYBOARDHIDDEN_YES, "keyshidden");
    map.put(KEYBOARDHIDDEN_SOFT, "keyssoft");
    KEYBOARDHIDDEN_VALUES = Collections.unmodifiableMap(map);
  }

  static final int NAVIGATION_NONAV     = 1;
  static final int NAVIGATION_DPAD      = 2;
  static final int NAVIGATION_TRACKBALL = 3;
  static final int NAVIGATION_WHEEL     = 4;

  private static final Map<Integer, String> NAVIGATION_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(NAVIGATION_NONAV, "nonav");
    map.put(NAVIGATION_DPAD, "dpad");
    map.put(NAVIGATION_TRACKBALL, "trackball");
    map.put(NAVIGATION_WHEEL, "wheel");
    NAVIGATION_VALUES = Collections.unmodifiableMap(map);
  }

  static final int NAVIGATIONHIDDEN_MASK  = 0x0C;
  static final int NAVIGATIONHIDDEN_NO    = 0x04;
  static final int NAVIGATIONHIDDEN_YES   = 0x08;

  private static final Map<Integer, String> NAVIGATIONHIDDEN_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(NAVIGATIONHIDDEN_NO, "navexposed");
    map.put(NAVIGATIONHIDDEN_YES, "navhidden");
    NAVIGATIONHIDDEN_VALUES = Collections.unmodifiableMap(map);
  }

  static final int ORIENTATION_PORTRAIT  = 0x01;
  static final int ORIENTATION_LANDSCAPE = 0x02;

  private static final Map<Integer, String> ORIENTATION_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(ORIENTATION_PORTRAIT, "port");
    map.put(ORIENTATION_LANDSCAPE, "land");
    ORIENTATION_VALUES = Collections.unmodifiableMap(map);
  }

  static final int SCREENLAYOUT_LAYOUTDIR_MASK = 0xC0;
  static final int SCREENLAYOUT_LAYOUTDIR_LTR  = 0x40;
  static final int SCREENLAYOUT_LAYOUTDIR_RTL  = 0x80;

  private static final Map<Integer, String> SCREENLAYOUT_LAYOUTDIR_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(SCREENLAYOUT_LAYOUTDIR_LTR, "ldltr");
    map.put(SCREENLAYOUT_LAYOUTDIR_RTL, "ldrtl");
    SCREENLAYOUT_LAYOUTDIR_VALUES = Collections.unmodifiableMap(map);
  }

  static final int SCREENLAYOUT_LONG_MASK = 0x30;
  static final int SCREENLAYOUT_LONG_NO   = 0x10;
  static final int SCREENLAYOUT_LONG_YES  = 0x20;

  private static final Map<Integer, String> SCREENLAYOUT_LONG_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(SCREENLAYOUT_LONG_NO, "notlong");
    map.put(SCREENLAYOUT_LONG_YES, "long");
    SCREENLAYOUT_LONG_VALUES = Collections.unmodifiableMap(map);
  }

  static final int SCREENLAYOUT_ROUND_MASK = 0x03;
  static final int SCREENLAYOUT_ROUND_NO   = 0x01;
  static final int SCREENLAYOUT_ROUND_YES  = 0x02;

  private static final Map<Integer, String> SCREENLAYOUT_ROUND_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(SCREENLAYOUT_ROUND_NO, "notround");
    map.put(SCREENLAYOUT_ROUND_YES, "round");
    SCREENLAYOUT_ROUND_VALUES = Collections.unmodifiableMap(map);
  }

  static final int SCREENLAYOUT_SIZE_MASK   = 0x0F;
  static final int SCREENLAYOUT_SIZE_SMALL  = 0x01;
  static final int SCREENLAYOUT_SIZE_NORMAL = 0x02;
  static final int SCREENLAYOUT_SIZE_LARGE  = 0x03;
  static final int SCREENLAYOUT_SIZE_XLARGE = 0x04;

  private static final Map<Integer, String> SCREENLAYOUT_SIZE_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(SCREENLAYOUT_SIZE_SMALL, "small");
    map.put(SCREENLAYOUT_SIZE_NORMAL, "normal");
    map.put(SCREENLAYOUT_SIZE_LARGE, "large");
    map.put(SCREENLAYOUT_SIZE_XLARGE, "xlarge");
    SCREENLAYOUT_SIZE_VALUES = Collections.unmodifiableMap(map);
  }

  static final int TOUCHSCREEN_NOTOUCH = 1;
  static final int TOUCHSCREEN_FINGER  = 3;

  private static final Map<Integer, String> TOUCHSCREEN_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(TOUCHSCREEN_NOTOUCH, "notouch");
    map.put(TOUCHSCREEN_FINGER, "finger");
    TOUCHSCREEN_VALUES = Collections.unmodifiableMap(map);
  }

  static final int UI_MODE_NIGHT_MASK = 0x30;
  static final int UI_MODE_NIGHT_NO   = 0x10;
  static final int UI_MODE_NIGHT_YES  = 0x20;

  private static final Map<Integer, String> UI_MODE_NIGHT_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(UI_MODE_NIGHT_NO, "notnight");
    map.put(UI_MODE_NIGHT_YES, "night");
    UI_MODE_NIGHT_VALUES = Collections.unmodifiableMap(map);
  }

  static final int UI_MODE_TYPE_MASK       = 0x0F;
  static final int UI_MODE_TYPE_DESK       = 0x02;
  static final int UI_MODE_TYPE_CAR        = 0x03;
  static final int UI_MODE_TYPE_TELEVISION = 0x04;
  static final int UI_MODE_TYPE_APPLIANCE  = 0x05;
  static final int UI_MODE_TYPE_WATCH      = 0x06;
  static final int UI_MODE_TYPE_VR_HEADSET = 0x07;

  private static final Map<Integer, String> UI_MODE_TYPE_VALUES;

  static {
    Map<Integer, String> map = new HashMap<>();
    map.put(UI_MODE_TYPE_DESK, "desk");
    map.put(UI_MODE_TYPE_CAR, "car");
    map.put(UI_MODE_TYPE_TELEVISION, "television");
    map.put(UI_MODE_TYPE_APPLIANCE, "appliance");
    map.put(UI_MODE_TYPE_WATCH, "watch");
    map.put(UI_MODE_TYPE_VR_HEADSET, "vrheadset");
    UI_MODE_TYPE_VALUES = Collections.unmodifiableMap(map);
  }

  /** The minimum size in bytes that a {@link ResourceConfiguration} can be. */
  private static final int MIN_SIZE = 28;

  /** The minimum size in bytes that this configuration must be to contain screen config info. */
  private static final int SCREEN_CONFIG_MIN_SIZE = 32;

  /** The minimum size in bytes that this configuration must be to contain screen dp info. */
  private static final int SCREEN_DP_MIN_SIZE = 36;

  /** The minimum size in bytes that this configuration must be to contain locale info. */
  private static final int LOCALE_MIN_SIZE = 48;

  /** The minimum size in bytes that this config must be to contain the screenConfig extension. */
  private static final int SCREEN_CONFIG_EXTENSION_MIN_SIZE = 52;

  /** The size of resource configurations in bytes for the latest version of Android resources. */
  public static final int SIZE = SCREEN_CONFIG_EXTENSION_MIN_SIZE;

  /** The number of bytes that this resource configuration takes up. */
  public abstract int size();

  public abstract int mcc();
  public abstract int mnc();

  /** Returns a packed 2-byte language code. */
  @SuppressWarnings("mutable")
  public abstract byte[] language();

  /** Returns {@link #language} as an unpacked string representation. */
  public final String languageString() {
    return unpackLanguage();
  }

  /** Returns a packed 2-byte region code. */
  @SuppressWarnings("mutable")
  public abstract byte[] region();

  /** Returns {@link #region} as an unpacked string representation. */
  public final String regionString() {
    return unpackRegion();
  }

  public abstract int orientation();
  public abstract int touchscreen();
  public abstract int density();
  public abstract int keyboard();
  public abstract int navigation();
  public abstract int inputFlags();

  public final int keyboardHidden() {
    return inputFlags() & KEYBOARDHIDDEN_MASK;
  }

  public final int navigationHidden() {
    return inputFlags() & NAVIGATIONHIDDEN_MASK;
  }

  public abstract int screenWidth();
  public abstract int screenHeight();
  public abstract int sdkVersion();

  /**
   * Returns a copy of this resource configuration with a different {@link #sdkVersion}, or this
   * configuration if the {@code sdkVersion} is the same.
   *
   * @param sdkVersion The SDK version of the returned configuration.
   * @return A copy of this configuration with the only difference being #sdkVersion.
   */
  public final ResourceConfiguration withSdkVersion(int sdkVersion) {
    return toBuilder().sdkVersion(sdkVersion).build();
  }

  public abstract int minorVersion();
  public abstract int screenLayout();

  public final int screenLayoutDirection() {
    return screenLayout() & SCREENLAYOUT_LAYOUTDIR_MASK;
  }

  public final int screenLayoutSize() {
    return screenLayout() & SCREENLAYOUT_SIZE_MASK;
  }

  public final int screenLayoutLong() {
    return screenLayout() & SCREENLAYOUT_LONG_MASK;
  }

  public final int screenLayoutRound() {
    return screenLayout2() & SCREENLAYOUT_ROUND_MASK;
  }

  public abstract int uiMode();

  public final int uiModeType() {
    return uiMode() & UI_MODE_TYPE_MASK;
  }

  public final int uiModeNight() {
    return uiMode() & UI_MODE_NIGHT_MASK;
  }

  public abstract int smallestScreenWidthDp();
  public abstract int screenWidthDp();
  public abstract int screenHeightDp();

  /** The ISO-15924 short name for the script corresponding to this configuration. */
  @SuppressWarnings("mutable")
  public abstract byte[] localeScript();

  /** Returns the {@link #localeScript} as a string. */
  public final String localeScriptString() {
    return byteArrayToString(localeScript());
  }

  /** A single BCP-47 variant subtag. */
  @SuppressWarnings("mutable")
  public abstract byte[] localeVariant();

  /** Returns the {@link #localeVariant} as a string. */
  public final String localeVariantString() {
    return byteArrayToString(localeVariant());
  }

  /** An extension to {@link #screenLayout}. Contains round/notround qualifier. */
  public abstract int screenLayout2();

  /** Wide-gamut, HDR, etc. */
  public abstract int colorMode();

  /** Returns the wide color gamut section of {@link #colorMode}. */
  public final int colorModeWideColorGamut() {
    return colorMode() & COLOR_MODE_WIDE_COLOR_GAMUT_MASK;
  }

  /** Returns the HDR section of {@link #colorMode}. */
  public final int colorModeHdr() {
    return colorMode() & COLOR_MODE_HDR_MASK;
  }

  /** Any remaining bytes in this resource configuration that are unaccounted for. */
  @SuppressWarnings("mutable")
  public abstract byte[] unknown();

  /** Returns this {@link ResourceConfiguration} as a builder. */
  public abstract Builder toBuilder();

  /** Returns a {@link Builder} with sane default properties. */
  public static Builder builder() {
    return new AutoValue_ResourceConfiguration.Builder()
        .size(SIZE)
        .mcc(0)
        .mnc(0)
        .language(new byte[2])
        .region(new byte[2])
        .orientation(0)
        .touchscreen(0)
        .density(0)
        .keyboard(0)
        .navigation(0)
        .inputFlags(0)
        .screenWidth(0)
        .screenHeight(0)
        .sdkVersion(0)
        .minorVersion(0)
        .screenLayout(0)
        .uiMode(0)
        .smallestScreenWidthDp(0)
        .screenWidthDp(0)
        .screenHeightDp(0)
        .localeScript(new byte[4])
        .localeVariant(new byte[8])
        .screenLayout2(0)
        .colorMode(0)
        .unknown(new byte[0]);
  }

  static ResourceConfiguration create(ByteBuffer buffer) {
    int startPosition = buffer.position();  // The starting buffer position to calculate bytes read.
    int size = buffer.getInt();
    Preconditions.checkArgument(size >= MIN_SIZE,
        "Expected minimum ResourceConfiguration size of %s, got %s", MIN_SIZE, size);
    // Builder order is important here. It's the same order as the data stored in the buffer.
    // The order of the builder's method calls, such as #mcc and #mnc, should not be changed.
    Builder configurationBuilder = builder()
        .size(size)
        .mcc(buffer.getShort() & 0xFFFF)
        .mnc(buffer.getShort() & 0xFFFF);
    byte[] language = new byte[2];
    buffer.get(language);
    byte[] region = new byte[2];
    buffer.get(region);
    configurationBuilder.language(language)
        .region(region)
        .orientation(UnsignedBytes.toInt(buffer.get()))
        .touchscreen(UnsignedBytes.toInt(buffer.get()))
        .density(buffer.getShort() & 0xFFFF)
        .keyboard(UnsignedBytes.toInt(buffer.get()))
        .navigation(UnsignedBytes.toInt(buffer.get()))
        .inputFlags(UnsignedBytes.toInt(buffer.get()));
    buffer.get();  // 1 byte of padding
    configurationBuilder.screenWidth(buffer.getShort() & 0xFFFF)
        .screenHeight(buffer.getShort() & 0xFFFF)
        .sdkVersion(buffer.getShort() & 0xFFFF)
        .minorVersion(buffer.getShort() & 0xFFFF);

    // At this point, the configuration's size needs to be taken into account as not all
    // configurations have all values.
    if (size >= SCREEN_CONFIG_MIN_SIZE) {
      configurationBuilder.screenLayout(UnsignedBytes.toInt(buffer.get()))
          .uiMode(UnsignedBytes.toInt(buffer.get()))
          .smallestScreenWidthDp(buffer.getShort() & 0xFFFF);
    }

    if (size >= SCREEN_DP_MIN_SIZE) {
      configurationBuilder.screenWidthDp(buffer.getShort() & 0xFFFF)
          .screenHeightDp(buffer.getShort() & 0xFFFF);
    }

    if (size >= LOCALE_MIN_SIZE) {
      byte[] localeScript = new byte[4];
      buffer.get(localeScript);
      byte[] localeVariant = new byte[8];
      buffer.get(localeVariant);
      configurationBuilder.localeScript(localeScript)
          .localeVariant(localeVariant);
    }

    if (size >= SCREEN_CONFIG_EXTENSION_MIN_SIZE) {
      configurationBuilder.screenLayout2(UnsignedBytes.toInt(buffer.get()));
      configurationBuilder.colorMode(UnsignedBytes.toInt(buffer.get()));
      buffer.getShort();  // More reserved padding
    }

    // After parsing everything that's known, account for anything that's unknown.
    int bytesRead = buffer.position() - startPosition;
    byte[] unknown = new byte[size - bytesRead];
    buffer.get(unknown);
    configurationBuilder.unknown(unknown);

    return configurationBuilder.build();
  }

  private String unpackLanguage() {
    return unpackLanguage(language());
  }

  public static String unpackLanguage(byte[] language) {
    return unpackLanguageOrRegion(language, 0x61);
  }

  private String unpackRegion() {
    return unpackLanguageOrRegion(region(), 0x30);
  }

  private static String unpackLanguageOrRegion(byte[] value, int base) {
    Preconditions.checkState(value.length == 2, "Language or region value must be 2 bytes.");
    if (value[0] == 0 && value[1] == 0) {
      return "";
    }
    if ((UnsignedBytes.toInt(value[0]) & 0x80) != 0) {
      byte[] result = new byte[3];
      result[0] = (byte) (base + (value[1] & 0x1F));
      result[1] = (byte) (base + ((value[1] & 0xE0) >>> 5) + ((value[0] & 0x03) << 3));
      result[2] = (byte) (base + ((value[0] & 0x7C) >>> 2));
      return new String(result, Charsets.US_ASCII);
    }
    return new String(value, Charsets.US_ASCII);
  }

  /**
   * Packs a 2 or 3 character language string into two bytes. If this is a 2 character string the
   * returned bytes is simply the string bytes, if this is a 3 character string we use a packed
   * format where the two bytes are:
   *
   * <pre>
   *  +--+--+--+--+--+--+--+--+  +--+--+--+--+--+--+--+--+
   *  |B |2 |2 |2 |2 |2 |1 |1 |  |1 |1 |1 |0 |0 |0 |0 |0 |
   *  +--+--+--+--+--+--+--+--+  +--+--+--+--+--+--+--+--+
   * </pre>
   *
   * <p>B : if bit set indicates this is a 3 character string (languages are always old style 7 bit
   * ascii chars only, so this is never set for a two character language)
   *
   * <p>2: The third character - 0x61
   *
   * <p>1: The second character - 0x61
   *
   * <p>0: The first character - 0x61
   *
   * <p>Languages are always lower case chars, so max is within 5 bits (z = 11001)
   *
   * @param language The language to pack.
   * @return The two byte representation of the language
   */
  public static byte[] packLanguage(String language) {
    byte[] unpacked = language.getBytes(Charsets.US_ASCII);
    if (unpacked.length == 2) {
      return unpacked;
    }
    int base = 0x61;
    byte[] result = new byte[2];
    Preconditions.checkState(unpacked.length == 3);
    for (byte value : unpacked) {
      Preconditions.checkState(value >= 'a' && value <= 'z');
    }
    result[0] = (byte) (((unpacked[2] - base) << 2) | ((unpacked[1] - base) >> 3) | 0x80);
    result[1] = (byte) ((unpacked[0] - base) | ((unpacked[1] - base) << 5));
    return result;
  }

  private String byteArrayToString(byte[] data) {
    int length = Bytes.indexOf(data, (byte) 0);
    return new String(data, 0, length >= 0 ? length : data.length, Charsets.US_ASCII);
  }

  /** Returns true if this is the default "any" configuration. */
  public final boolean isDefault() {
    // Ignore size and unknown when checking if this is the default configuration. It's possible
    // that we're comparing against a different version.
    return DEFAULT_BUILDER.size(size()).unknown(unknown()).build().equals(this)
        && Arrays.equals(unknown(), new byte[unknown().length]);
  }

  public final boolean isDensityCompatibleWith(int deviceDensityDpi) {
    int configDensity = density();
    switch (configDensity) {
      case DENSITY_DPI_UNDEFINED:
      case DENSITY_DPI_ANY:
      case DENSITY_DPI_NONE:
        return true;
      default:
        return configDensity <= deviceDensityDpi;
    }
  }

  @Override
  public final byte[] toByteArray() {
    return toByteArray(SerializableResource.NONE);
  }

  @Override
  public final byte[] toByteArray(int options) {
    ByteBuffer buffer = ByteBuffer.allocate(size()).order(ByteOrder.LITTLE_ENDIAN);
    buffer.putInt(size());
    buffer.putShort((short) mcc());
    buffer.putShort((short) mnc());
    buffer.put(language());
    buffer.put(region());
    buffer.put((byte) orientation());
    buffer.put((byte) touchscreen());
    buffer.putShort((short) density());
    buffer.put((byte) keyboard());
    buffer.put((byte) navigation());
    buffer.put((byte) inputFlags());
    buffer.put((byte) 0);  // Padding
    buffer.putShort((short) screenWidth());
    buffer.putShort((short) screenHeight());
    buffer.putShort((short) sdkVersion());
    buffer.putShort((short) minorVersion());

    if (size() >= SCREEN_CONFIG_MIN_SIZE) {
      buffer.put((byte) screenLayout());
      buffer.put((byte) uiMode());
      buffer.putShort((short) smallestScreenWidthDp());
    }

    if (size() >= SCREEN_DP_MIN_SIZE) {
      buffer.putShort((short) screenWidthDp());
      buffer.putShort((short) screenHeightDp());
    }

    if (size() >= LOCALE_MIN_SIZE) {
      buffer.put(localeScript());
      buffer.put(localeVariant());
    }

    if (size() >= SCREEN_CONFIG_EXTENSION_MIN_SIZE) {
      buffer.put((byte) screenLayout2());
      buffer.put((byte) colorMode());
      buffer.putShort((short) 0); // Writing 2 bytes of padding
    }

    buffer.put(unknown());

    return buffer.array();
  }

  @Override
  public final String toString() {
    if (isDefault()) {  // Prevent the default configuration from returning the empty string
      return "default";
    }
    Map<Type, String> parts = toStringParts();
    mergeLocale(parts);
    Collection<String> values = parts.values();
    values.removeAll(Collections.singleton(""));
    return Joiner.on('-').join(values);
  }

  /**
   * Merges the locale for {@code parts} if necessary.
   *
   * <p>Android supports a modified BCP 47 tag containing script and variant. If script or variant
   * are provided in the configuration, then the locale section should appear as:
   *
   * <p>{@code b+language+script+region+variant}
   */
  private void mergeLocale(Map<Type, String> parts) {
    String script = localeScriptString();
    String variant = localeVariantString();
    if (script.isEmpty() && variant.isEmpty()) {
      return;
    }
    StringBuilder locale = new StringBuilder("b+").append(languageString());
    if (!script.isEmpty()) {
      locale.append("+" + script);
    }
    String region = regionString();
    if (!region.isEmpty()) {
      locale.append("+" + region);
    }
    if (!variant.isEmpty()) {
      locale.append("+" + variant);
    }
    parts.put(Type.LANGUAGE_STRING, locale.toString());
    parts.remove(Type.LOCALE_SCRIPT_STRING);
    parts.remove(Type.REGION_STRING);
    parts.remove(Type.LOCALE_VARIANT_STRING);
  }

  /**
   * Returns a map of the configuration parts for {@link #toString}.
   *
   * <p>If a configuration part is not defined for this {@link ResourceConfiguration}, its value
   * will be the empty string.
   */
  public final Map<Type, String> toStringParts() {
    Map<Type, String> result = new LinkedHashMap<>();  // Preserve order for #toString().
    result.put(Type.MCC, mcc() != 0 ? "mcc" + mcc() : "");
    result.put(Type.MNC, mnc() != 0 ? "mnc" + mnc() : "");
    result.put(Type.LANGUAGE_STRING, languageString());
    result.put(Type.LOCALE_SCRIPT_STRING, localeScriptString());
    result.put(Type.REGION_STRING, !regionString().isEmpty() ? "r" + regionString() : "");
    result.put(Type.LOCALE_VARIANT_STRING, localeVariantString());
    result.put(Type.SCREEN_LAYOUT_DIRECTION,
        getOrDefault(SCREENLAYOUT_LAYOUTDIR_VALUES, screenLayoutDirection(), ""));
    result.put(Type.SMALLEST_SCREEN_WIDTH_DP,
        smallestScreenWidthDp() != 0 ? "sw" + smallestScreenWidthDp() + "dp" : "");
    result.put(Type.SCREEN_WIDTH_DP, screenWidthDp() != 0 ? "w" + screenWidthDp() + "dp" : "");
    result.put(Type.SCREEN_HEIGHT_DP, screenHeightDp() != 0 ? "h" + screenHeightDp() + "dp" : "");
    result.put(Type.SCREEN_LAYOUT_SIZE,
        getOrDefault(SCREENLAYOUT_SIZE_VALUES, screenLayoutSize(), ""));
    result.put(Type.SCREEN_LAYOUT_LONG,
        getOrDefault(SCREENLAYOUT_LONG_VALUES, screenLayoutLong(), ""));
    result.put(Type.SCREEN_LAYOUT_ROUND,
        getOrDefault(SCREENLAYOUT_ROUND_VALUES, screenLayoutRound(), ""));
    result.put(Type.COLOR_MODE_HDR, getOrDefault(COLOR_MODE_HDR_VALUES, colorModeHdr(), ""));
    result.put(
        Type.COLOR_MODE_WIDE_COLOR_GAMUT,
        getOrDefault(COLOR_MODE_WIDE_COLOR_GAMUT_VALUES, colorModeWideColorGamut(), ""));
    result.put(Type.ORIENTATION, getOrDefault(ORIENTATION_VALUES, orientation(), ""));
    result.put(Type.UI_MODE_TYPE, getOrDefault(UI_MODE_TYPE_VALUES, uiModeType(), ""));
    result.put(Type.UI_MODE_NIGHT, getOrDefault(UI_MODE_NIGHT_VALUES, uiModeNight(), ""));
    result.put(Type.DENSITY_DPI, getOrDefault(DENSITY_DPI_VALUES, density(), density() + "dpi"));
    result.put(Type.TOUCHSCREEN, getOrDefault(TOUCHSCREEN_VALUES, touchscreen(), ""));
    result.put(Type.KEYBOARD_HIDDEN, getOrDefault(KEYBOARDHIDDEN_VALUES, keyboardHidden(), ""));
    result.put(Type.KEYBOARD, getOrDefault(KEYBOARD_VALUES, keyboard(), ""));
    result.put(Type.NAVIGATION_HIDDEN,
        getOrDefault(NAVIGATIONHIDDEN_VALUES, navigationHidden(), ""));
    result.put(Type.NAVIGATION, getOrDefault(NAVIGATION_VALUES, navigation(), ""));
    result.put(Type.SCREEN_SIZE,
        screenWidth() != 0 || screenHeight() != 0 ? screenWidth() + "x" + screenHeight() : "");

    String sdkVersion = "";
    if (sdkVersion() != 0) {
      sdkVersion = "v" + sdkVersion();
      if (minorVersion() != 0) {
        sdkVersion += "." + minorVersion();
      }
    }
    result.put(Type.SDK_VERSION, sdkVersion);
    return result;
  }

  private <K, V> V getOrDefault(Map<K, V> map, K key, V defaultValue) {
    // TODO(acornwall): Remove this when Java 8's Map#getOrDefault is available.
    // Null is not returned, even if the map contains a key whose value is null. This is intended.
    V value = map.get(key);
    return value != null ? value : defaultValue;
  }

  /** Provides a builder for creating {@link ResourceConfiguration} instances. */
  @AutoValue.Builder
  public abstract static class Builder {

    public abstract Builder size(int size);
    public abstract Builder mcc(int mcc);
    public abstract Builder mnc(int mnc);
    public abstract Builder language(byte[] language);
    public abstract Builder region(byte[] region);
    public abstract Builder orientation(int orientation);
    public abstract Builder touchscreen(int touchscreen);
    public abstract Builder density(int density);
    public abstract Builder keyboard(int keyboard);
    public abstract Builder navigation(int navigation);
    public abstract Builder inputFlags(int inputFlags);
    public abstract Builder screenWidth(int screenWidth);
    public abstract Builder screenHeight(int screenHeight);
    public abstract Builder sdkVersion(int sdkVersion);
    public abstract Builder minorVersion(int minorVersion);
    public abstract Builder screenLayout(int screenLayout);
    public abstract Builder uiMode(int uiMode);
    public abstract Builder smallestScreenWidthDp(int smallestScreenWidthDp);
    public abstract Builder screenWidthDp(int screenWidthDp);
    public abstract Builder screenHeightDp(int screenHeightDp);
    public abstract Builder localeScript(byte[] localeScript);
    public abstract Builder localeVariant(byte[] localeVariant);
    public abstract Builder screenLayout2(int screenLayout2);

    public abstract Builder colorMode(int colorMode);

    abstract Builder unknown(byte[] unknown);

    public abstract ResourceConfiguration build();
  }
}
